﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Sisocana.Core.Interfaces;
using Sisocana.Dal.Interfaces;
using Sisocana.Dal;
using Sisocana.Dal.EntityModels;
using Sisocana.Core.Models;
using System.Linq.Expressions;

namespace Sisocana.Core
{
    public class PersonaService : ServiceBase<IPersonaModel>, IPersonaService
    {
        public DataImagen GetPhoto(int id)
        {
            var persona = personaRepo.GetSingle(p => p.id == id);
            return new DataImagen(persona.foto);
        }

        public PersonaAyudaModel LatestHelpRequests(int idSitio, int lastHelpRequestId)
        {
            PersonaAyuda persona = personaRepo.GetQueryable()
                                    .Where(p => p.id > lastHelpRequestId)
                                    .Where(p => p.Sitio.id == idSitio)
                                    .OfType<PersonaAyuda>()
                                    .OrderBy(p => p.id).FirstOrDefault();
            if (persona == null)
                return null;
            createPersonaAyudaMapperEF2Model();
            PersonaAyudaModel pedidoAyuda = new PersonaAyudaModel();
            pedidoAyuda = AutoMapper.Mapper.Map(persona, pedidoAyuda);
            return pedidoAyuda;
        }

        #region PersonaDesaparecida

        public void createPersonaDesaparecidaMapperEF2Model()
        {
            AutoMapper.Mapper.CreateMap<PersonaDesaparecida, PersonaDesaparecidaModel>()
              .ForMember(dest => dest.idSitio, opt => opt.MapFrom(src => src.Sitio.id))
              .ForMember(dest => dest.foto, opt => opt.MapFrom(src => new DataImagen(src.foto)));                
        }

        public void createPersonaDesaparecidaMapperModel2EF()
        {
            AutoMapper.Mapper.CreateMap<PersonaDesaparecidaModel, PersonaDesaparecida>()
              .ForMember(p => p.foto, opt => opt.MapFrom(personModel => DataImagen.GetImage(personModel.foto)));
        }

        public void createMissingPersonToFullModelMapper()
        {
            AutoMapper.Mapper.CreateMap<PersonaDesaparecida, PersonaDesaparecidaFullModel>()
              .ForMember(dest => dest.idSitio, opt => opt.MapFrom(src => src.Sitio.id))
              .ForMember(dest => dest.foto, opt => opt.MapFrom(src => new DataImagen(src.foto)));
        }

        public void createPersonaDesaparecidaFull2Model()
        {
            AutoMapper.Mapper.CreateMap<PersonaDesaparecidaFull, PersonaDesaparecidaFullModel>()
                .ForMember(dest => dest.Reports, opt => opt.Ignore())
                .ForMember(dest => dest.HomeAddress, opt => opt.Ignore())
                .ForMember(dest => dest.foto, opt => opt.MapFrom(src => new DataImagen(src.foto)));
        }

        public void createReporteEF2Model()
        {
            AutoMapper.Mapper.CreateMap<Reporte, ReporteModel>()
            .ForMember(dest => dest.searchWSId, opt => opt.Ignore())
            .ForMember(dest => dest.externalEntity, opt => opt.Ignore());

        }

        public void createPersonaDesaparecidaExtEF2Model()
        {
            AutoMapper.Mapper.CreateMap<PersonaDesaparecida, PersonaDesaparecidaModel>()
            .ForMember(dest => dest.idSitio, opt => opt.Ignore())
            .ForMember(dest => dest.foto, opt => opt.MapFrom(src => new DataImagen(src.foto)));  
        }

        public int crearRegistroPersonaDesaparecida(PersonaDesaparecidaModel personaModel, DireccionModel direccionModel, ReporteModel reporteModel)
        {
            createPersonaDesaparecidaMapperModel2EF();
            PersonaDesaparecida persona = new PersonaDesaparecida();
            persona = AutoMapper.Mapper.Map(personaModel, persona);
            persona.Sitio = siteRepo.GetSingle(sitio => sitio.id == personaModel.idSitio);

            AutoMapper.Mapper.CreateMap<DireccionModel, Direccion>();
            Direccion direccion = new Direccion();
            direccion = AutoMapper.Mapper.Map(direccionModel, direccion);

            AutoMapper.Mapper.CreateMap<ReporteModel, Reporte>();
            Reporte reporte = new Reporte();
            reporte = AutoMapper.Mapper.Map(reporteModel, reporte);
            reporte.fecha = DateTime.Now;

            persona.Direccion = direccion;
            persona.Reportes.Add(reporte);
            reporte.PersonaDesaparecida = persona;

            personaRepo.Add(persona);
            personaRepo.Save();

            return persona.id;
        }

        public int agregarReportePersonaDesaparecida(int idSitio, ReporteModel reporteModel)
        {
            PersonaDesaparecida persona = personaRepo.GetSingle(p => p.id == reporteModel.idPersona) as PersonaDesaparecida;

            AutoMapper.Mapper.CreateMap<ReporteModel, Reporte>();
            Reporte reporte = new Reporte();
            reporte = AutoMapper.Mapper.Map(reporteModel, reporte);
            reporte.fecha = DateTime.Now;
            int result = -1;
            if (reporteModel.externalEntity)
            {
                WSBusquedaRepository wsr = new WSBusquedaRepository();
                IList<WsBusqueda> wss = wsr.GetAll(ws => ws.Sitio.id == idSitio && ws.id == reporteModel.searchWSId);
                string url = wss.First().url;
                result = personaRepo.agregarReporte(url, reporteModel.siteId, reporteModel.idPersona, reporte);
            }
            else
            {
                try
                {
                    persona.Reportes.Add(reporte);
                    reporte.PersonaDesaparecida = persona;
                    personaRepo.Save();
                    result = 0;
                }
                catch (Exception e)
                {
                    result = -1;
                }
            }
            return result;
        }


        public void agregarReportePersonaDesaparecidaLocal(ReporteModel reporteModel)
        {
            PersonaDesaparecida persona = personaRepo.GetSingle(p => p.id == reporteModel.idPersona) as PersonaDesaparecida;

            AutoMapper.Mapper.CreateMap<ReporteModel, Reporte>();
            Reporte reporte = new Reporte();
            reporte = AutoMapper.Mapper.Map(reporteModel, reporte);
            reporte.fecha = DateTime.Now;

            persona.Reportes.Add(reporte);
            reporte.PersonaDesaparecida = persona;

            personaRepo.Save();
        }

        public PersonaDesaparecidaModel findPersonaDesaparecida(int idSitio, int id)
        {
            createPersonaDesaparecidaMapperEF2Model();
            PersonaDesaparecida persona = personaRepo.GetSingle(per => (per.Sitio.id == idSitio) && (per.id == id)) as PersonaDesaparecida;
            PersonaDesaparecidaModel p = new PersonaDesaparecidaModel();
            p = new PersonaDesaparecidaModel();
            p = AutoMapper.Mapper.Map(persona, p);
            return p;
        }

        public DireccionModel findDireccion(int idSitio, int id)
        {
            AutoMapper.Mapper.CreateMap<Direccion, DireccionModel>();

            PersonaDesaparecida persona = personaRepo.GetSingle(per => (per.Sitio.id == idSitio) && (per.id == id)) as PersonaDesaparecida;

            Direccion d = persona.Direccion;
            DireccionModel dm = new DireccionModel();
            dm = AutoMapper.Mapper.Map(d, dm);
            return dm;
        }

        public IList<ReporteModel> findReportes(int idSitio, int id)
        {

            PersonaDesaparecida persona = personaRepo.GetSingle(per => (per.Sitio.id == idSitio) && (per.id == id)) as PersonaDesaparecida;
            createReporteEF2Model();
            IList<ReporteModel> ret = new List<ReporteModel>();

            foreach (Reporte reporte in persona.Reportes)
            {
                ReporteModel reporteM = new ReporteModel();
                reporteM = AutoMapper.Mapper.Map(reporte, reporteM);
                ret.Add(reporteM);
            }

            return ret;
        }

        public IList<PersonaDesaparecidaFullModel> GetSimilar(int idSitio,string firstName, string lastName)
        {
            //var personasEF = personaRepo.GetAll().OfType<PersonaDesaparecida>();
            //List<PersonaDesaparecidaFullModel> personas = new List<PersonaDesaparecidaFullModel>();
            //foreach (PersonaDesaparecida persona in personasEF)
            //{
            //    if (persona.nombre.StartsWith(firstName) || persona.apellido.StartsWith(lastName))
            //    {
            //        createMissingPersonToFullModelMapper();
            //        PersonaDesaparecidaFullModel p = new PersonaDesaparecidaFullModel();
            //        p = AutoMapper.Mapper.Map(persona, p);
            //        AutoMapper.Mapper.CreateMap<Reporte, ReporteModel>();
            //        ReporteModel report = new ReporteModel();
            //        DateTime latestDate = persona.Reportes.Max(r => r.fecha);
            //        Reporte lastReport = persona.Reportes.Where(r => r.fecha >= latestDate).Single();
            //        report = AutoMapper.Mapper.Map(lastReport, report);
            //        p.Reports.Add(report);
            //        personas.Add(p);
            //    }
            //}
            //return personas;
            return SearchPersonAdvanced(idSitio, firstName, lastName, null, new DateTime(), new DateTime());
        }

        public IList<Models.PersonaDesaparecidaModel> SearchPersonByKeywordLocal(int idSitio, string keyword)
        {
            createPersonaDesaparecidaMapperEF2Model();
            var personasEF = personaRepo.GetAll().OfType<PersonaDesaparecida>();
            List<PersonaDesaparecidaModel> personas = new List<PersonaDesaparecidaModel>();
            if (keyword != null)
            {
                foreach (PersonaDesaparecida persona in personasEF)
                {
                    if ((persona.Sitio.id == idSitio || idSitio == 0) &&
                        (((persona.nombre != null) && (persona.nombre.IndexOf(keyword, StringComparison.OrdinalIgnoreCase)>=0))
                        || ((persona.apellido != null) && (persona.apellido.IndexOf(keyword, StringComparison.OrdinalIgnoreCase) >= 0))
                        || ((persona.celular !=null)&&(persona.celular.Contains(keyword)))
                        || ((persona.descripcion != null) && (persona.descripcion.IndexOf(keyword, StringComparison.OrdinalIgnoreCase) >= 0))))
                    {
                        PersonaDesaparecidaModel p = new PersonaDesaparecidaModel();
                        p = AutoMapper.Mapper.Map(persona, p);
                        personas.Add(p);
                    }
                }
            }
            return personas;
        }

        public IList<Models.PersonaDesaparecidaModel> SearchPersonByKeywordLocal(string keyword)
        {
            return SearchPersonByKeywordLocal(0, keyword);
        }

        public IList<Models.PersonaDesaparecidaModel> SearchPersonByKeyWordExterno(int idSitio, string keyword)
        {
            createPersonaDesaparecidaMapperEF2Model();
            List<PersonaDesaparecidaModel> personas = new List<PersonaDesaparecidaModel>();

            WSBusquedaRepository wsr = new WSBusquedaRepository();
            IList<WsBusqueda> wss = wsr.GetAll(ws => ws.Sitio.id == idSitio);

            foreach (var item in wss)
            {
                var personasEF = personaRepo.personasBusquedaExternaKeyWord(item.url, keyword);

                foreach (PersonaDesaparecida persona in personasEF)
                {
                        PersonaDesaparecidaModel p = new PersonaDesaparecidaModel();
                        p.nombre = persona.nombre;
                        p.apellido = persona.apellido;
                        p.celular = persona.celular;
                        p.descripcion = persona.descripcion;
                        p.descripcion = persona.descripcion;
                        p.fecha = persona.fecha;
                        p.id = persona.id;
                        p.idSitio = Convert.ToInt32(persona.edad);
                        p.edad = 0;
                        p.externalEntity = true;
                        p.searchWSId = item.id;
                        personas.Add(p);
                }
            }

            return personas;
        }

        public IList<Models.PersonaDesaparecidaFullModel> SearchPersonByKeyword(int idSitio, string keyword)
        {
            createPersonaDesaparecidaMapperEF2Model();
            IList<PersonaDesaparecidaModel> personas = new List<PersonaDesaparecidaModel>();
            personas = SearchPersonByKeywordLocal(idSitio, keyword);
            personas = personas.Concat(SearchPersonByKeyWordExterno(idSitio, keyword)).ToList();
            IList<PersonaDesaparecidaFullModel> ret = new List<PersonaDesaparecidaFullModel>();
            foreach (PersonaDesaparecidaModel per in personas)
            {
                PersonaDesaparecidaFullModel p = new PersonaDesaparecidaFullModel();
                p = completarInfo(idSitio,per.idSitio,per.id,per.externalEntity,per.searchWSId,per.nombre,per.apellido,per.fecha,per.celular);
                ret.Add(p);
            }
            return ret;
        }

        public IList<Models.PersonaDesaparecidaModel> SearchPersonAdvancedLocal(int idSitio, string firstName, string lastName, string phone, DateTime from, DateTime to)
        {
            createPersonaDesaparecidaMapperEF2Model();
            IList<Persona> personasEF = personaRepo.GetAll();
            IEnumerable<PersonaDesaparecida> desaparecidasEF = personasEF.OfType<PersonaDesaparecida>();

            List<PersonaDesaparecidaModel> desaparecidas = new List<PersonaDesaparecidaModel>();
            foreach (PersonaDesaparecida p in desaparecidasEF)
            {
                PersonaDesaparecidaModel pm = new PersonaDesaparecidaModel();
                pm = AutoMapper.Mapper.Map(p, pm);
                pm.idSitio = p.Sitio.id;
                desaparecidas.Add(pm);
            }
            IQueryable<PersonaDesaparecidaModel> desRet = desaparecidas.AsQueryable<PersonaDesaparecidaModel>();
            List<PersonaDesaparecidaModel> ret;

            //auxiliar para obtener la fecha vacia (no sirve comparar contra null)
            DateTime d = new DateTime();

            //si todos los filtros vienen vacios no devuelvo resultados
            if (firstName == null
                && lastName == null
                && phone == null
                && d.CompareTo(from) == 0
                && d.CompareTo(to) == 0)
                ret = new List<PersonaDesaparecidaModel>();
            //aplico los filtros(de busqueda y el de sitio) a los resultados
            else
            {
                if (idSitio != 0)
                    desRet = desRet.Where(persona => persona.idSitio == idSitio);
                if (firstName != null && firstName != "")
                    desRet = desRet.Where(persona => (persona.nombre != null) && (persona.nombre.IndexOf(firstName, StringComparison.OrdinalIgnoreCase) >= 0));
                if (lastName != null && lastName != "")
                    desRet = desRet.Where(persona => (persona.apellido != null) && (persona.apellido.IndexOf(lastName, StringComparison.OrdinalIgnoreCase) >= 0));
                if (phone != null && phone != "")
                    desRet = desRet.Where(persona => (persona.celular!=null) && (persona.celular.Contains(phone)));
                if (d.CompareTo(from) != 0)
                    desRet = desRet.Where(persona => (persona.fecha!=null)&&(persona.fecha >= from));
                if (d.CompareTo(to) != 0)
                    desRet = desRet.Where(persona => (persona.fecha!=null)&&(persona.fecha <= to));

                ret = desRet.ToList();
            }

            return ret;
        }

        public IList<Models.PersonaDesaparecidaModel> SearchPersonAdvancedLocal(string firstName, string lastName, string phone, DateTime from, DateTime to)
        {
            return SearchPersonAdvancedLocal(0, firstName, lastName, phone, from, to);
        }

        public IList<Models.PersonaDesaparecidaModel> SearchPersonAdvancedExterno(int idSitio, string firstName, string lastName, string phone, DateTime from, DateTime to)
        {
            createPersonaDesaparecidaExtEF2Model();
            List<PersonaDesaparecidaModel> personas = new List<PersonaDesaparecidaModel>();


            WSBusquedaRepository wsr = new WSBusquedaRepository();
            IList<WsBusqueda> wss = wsr.GetAll(ws => ws.Sitio.id == idSitio);

            foreach (var item in wss)
            {
                IList<PersonaDesaparecida> personasEF = personaRepo.personasBusquedaExternaAdvanced(item.url,firstName,lastName,phone,from,to);

                foreach (PersonaDesaparecida persona in personasEF)
                {
                    {
                        PersonaDesaparecidaModel p = new PersonaDesaparecidaModel();
                        p = AutoMapper.Mapper.Map(persona, p);

                        p.idSitio = Convert.ToInt32(persona.edad);
                        p.edad = 0;
                        p.externalEntity = true;
                        p.searchWSId = item.id;
                        personas.Add(p);
                    }
                }
            }
            return personas;
        }

        public IList<Models.PersonaDesaparecidaFullModel> SearchPersonAdvanced(int idSitio, string firstName, string lastName, string phone, DateTime from, DateTime to)
        {

            IList<PersonaDesaparecidaModel> personas = new List<PersonaDesaparecidaModel>();
            personas = SearchPersonAdvancedLocal(idSitio, firstName,lastName,phone,from,to);
            personas = personas.Concat(SearchPersonAdvancedExterno(idSitio, firstName,lastName,phone,from,to)).ToList();
            IList<PersonaDesaparecidaFullModel> ret = new List<PersonaDesaparecidaFullModel>();
            foreach (PersonaDesaparecidaModel per in personas)
            {
                PersonaDesaparecidaFullModel p = new PersonaDesaparecidaFullModel();
                p = completarInfo(idSitio, per.idSitio, per.id, per.externalEntity, per.searchWSId, per.nombre, per.apellido, per.fecha, per.celular);
                ret.Add(p);
            }
                
            return ret;
        }

        public PersonaDesaparecidaFullModel completarInfo(int idSitio,int personSiteId, int personId, bool externalEntity, int searchWSId,string name, string lastName,DateTime date, string phone)
        {
            createMissingPersonToFullModelMapper();
            AutoMapper.Mapper.CreateMap<Direccion, DireccionModel>();
            createReporteEF2Model();

            PersonaDesaparecidaFullModel p = new PersonaDesaparecidaFullModel();
            
            if (!externalEntity)
            //Pertenece al sitio
            {
                PersonaDesaparecida pEF = new PersonaDesaparecida();
                pEF = personaRepo.GetAll(pers => pers.id == personId).OfType<PersonaDesaparecida>().First();
                p = AutoMapper.Mapper.Map(pEF, p);
                ReporteModel report = new ReporteModel();
                DateTime latestDate = pEF.Reportes.Max(r => r.fecha);
                Reporte lastReport = pEF.Reportes.Where(r => r.fecha >= latestDate).Single();
                report = AutoMapper.Mapper.Map(lastReport, report);
                DireccionModel d = new DireccionModel();
                AutoMapper.Mapper.Map(pEF.Direccion, d);
                p.Reports.Add(report);
                p.TotalReports = pEF.Reportes.Count;
                p.HomeAddress = d;
            }
            else
            {
                createPersonaDesaparecidaFull2Model();
                WSBusquedaRepository wsr = new WSBusquedaRepository();
                IList<WsBusqueda> wss = wsr.GetAll(ws => ws.Sitio.id == idSitio && ws.id == searchWSId);
                string url = wss.First().url;
                PersonaDesaparecidaFull pdf = personaRepo.completarInfoExterna(url, personSiteId, personId);
                if (pdf != null)
                {
                    foreach (Reporte r in pdf.Reports)
                    {
                        ReporteModel rm = new ReporteModel();
                        rm = AutoMapper.Mapper.Map(r, rm);
                        p.Reports.Add(rm);
                    }
                    DireccionModel dm = new DireccionModel();
                    dm = AutoMapper.Mapper.Map(pdf.HomeAddress, dm);
                    p.HomeAddress = dm;
                    p.externalEntity = true;
                    p.searchWSId = searchWSId;
                    p = AutoMapper.Mapper.Map(pdf, p);
                    if (p.foto != null && p.foto.imgByte != null)
                    {
                        string imageBase64 = Convert.ToBase64String(p.foto.imgByte);
                        p.imageSrc = string.Format("data:image/gif;base64,{0}", imageBase64);
                    }
                }
                else
                {
                    p.id = personId;
                    p.idSitio = personSiteId;
                    p.searchWSId = searchWSId;
                    p.externalEntity = true;
                    p.nombre = name;
                    p.apellido = lastName;
                    p.celular = phone;
                    p.fecha = date;
                    ReporteModel rmd = new ReporteModel();
                    rmd.status = "U";
                    DireccionModel d = new DireccionModel();
                    p.HomeAddress = d;
                    p.Reports.Add(rmd);
                }
            }
            return p;
        }

        public IList<PersonaDesaparecidaModel> SearchPersonACJSON(int idSitio, string q, int limit)
        {

            List<PersonaDesaparecidaModel> personas = new List<PersonaDesaparecidaModel>();

            if (q != null)
            {
                createPersonaDesaparecidaMapperEF2Model();
                var personasEF = personaRepo.GetAll((p => p.Sitio.id == idSitio &&
                                                                (p.nombre.StartsWith(q) ||
                                                                 p.apellido.StartsWith(q)
                                                                 )
                                                              )).OfType<PersonaDesaparecida>();

                foreach (PersonaDesaparecida persona in personasEF)
                {
                    PersonaDesaparecidaModel p = new PersonaDesaparecidaModel();
                    p = AutoMapper.Mapper.Map(persona, p);
                    personas.Add(p);
                }

            }
            return personas;
        }



        #endregion

        #region PersonaAyuda

        public void createPersonaAyudaMapperEF2Model()
        {
            AutoMapper.Mapper.CreateMap<PersonaAyuda, PersonaAyudaModel>()
              .ForMember(dest => dest.idSitio, opt => opt.MapFrom(src => src.Sitio.id))
              .ForMember(dest => dest.foto, opt => opt.MapFrom(src => new DataImagen(src.foto)));     
        }

        public void createPersonaAyudaMapperModel2EF()
        {
            AutoMapper.Mapper.CreateMap<PersonaAyudaModel, PersonaAyuda>()
              .ForMember(p => p.foto, opt => opt.MapFrom(personModel => DataImagen.GetImage(personModel.foto)));
        }

        public int makeHelpRequest(PersonaAyudaModel persona)
        {
            persona.fecha = DateTime.Now;            
            createPersonaAyudaMapperModel2EF();

            PersonaAyuda helpRequest = new PersonaAyuda();
            AutoMapper.Mapper.Map(persona, helpRequest);
            helpRequest.Sitio = siteRepo.GetSingle(sitio => sitio.id == persona.idSitio);

            personaRepo.Add(helpRequest);
            personaRepo.Save();
            return helpRequest.id;
        }

        // La excepción en caso de que no exista la persona debería atajarse en el controlador, no aquí.
        public PersonaAyudaModel GetPersonaAyudaModel(int idPersona)
        {
            PersonaAyuda persona = personaRepo.GetSingle(p => p.id == idPersona) as PersonaAyuda;
            createPersonaAyudaMapperEF2Model();
            PersonaAyudaModel pedidoAyuda = new PersonaAyudaModel();
            pedidoAyuda = AutoMapper.Mapper.Map(persona, pedidoAyuda);
            return pedidoAyuda;
        }

        public IList<PersonaAyudaModel> GetAllPersonaAyudaModel(int idSitio)
        {
            IList<Persona> personas = personaRepo.GetAll(p => p.Sitio.id == idSitio);
            IEnumerable<PersonaAyuda> personasAyuda = personas.OfType<PersonaAyuda>().OrderBy(p => p.fecha);

            createPersonaAyudaMapperEF2Model();
            List<PersonaAyudaModel> pedidosAyuda = new List<PersonaAyudaModel>();
            pedidosAyuda = AutoMapper.Mapper.Map(personasAyuda, pedidosAyuda);

            return pedidosAyuda;
        }

        public IList<Models.PersonaAyudaModel> GetAllPersonaAyudaModel(System.Linq.Expressions.Expression<Func<Models.PersonaAyudaModel, bool>> whereCondition)
        {
            createPersonaAyudaMapperEF2Model();

            IList<Persona> donacionesEF = personaRepo.GetAll();
            IEnumerable<PersonaAyuda> bienesEF = donacionesEF.OfType<PersonaAyuda>();

            List<PersonaAyudaModel> donBienes = new List<PersonaAyudaModel>();

            donBienes = AutoMapper.Mapper.Map(bienesEF, donBienes);

            IQueryable<PersonaAyudaModel> donBienesRet = donBienes.AsQueryable<PersonaAyudaModel>().Where(whereCondition);
            donBienesRet = donBienesRet.OrderBy(ln => ln.fecha);
            List<PersonaAyudaModel> ret = donBienesRet.ToList();

            return ret;
        }
        
        #endregion

        #region Constructor/Variables
        private IPersonaRepository personaRepo;
        private ISiteRepository siteRepo;
        public PersonaService()
            : this(new PersonaRepository(), new SiteRepository())
        {
        }
        public PersonaService(IPersonaRepository personaRepository, ISiteRepository siteRepository)
        {
            personaRepo = personaRepository ?? new PersonaRepository();
            siteRepo = siteRepository ?? new SiteRepository();
        }
        #endregion

        #region Not implemented methods
        public PersonaModel GetSingle(Expression<Func<PersonaModel, bool>> whereCondition)
        {
            throw new NotImplementedException();
        }

        public void Add(PersonaModel entity)
        {
            throw new NotImplementedException();
        }

        public void Delete(PersonaModel entity)
        {
            throw new NotImplementedException();
        }

        public void Update(PersonaModel entity)
        {
            throw new NotImplementedException();
        }

        public IList<PersonaModel> GetAll(Expression<Func<PersonaModel, bool>> whereCondition)
        {
            throw new NotImplementedException();
        }

        IList<PersonaModel> IService<PersonaModel>.GetAll()
        {
            throw new NotImplementedException();
        }

        public IQueryable<PersonaModel> Query(Expression<Func<PersonaModel, bool>> whereCondition)
        {
            throw new NotImplementedException();
        }

        public long Count(Expression<Func<PersonaModel, bool>> whereCondition)
        {
            throw new NotImplementedException();
        }
        #endregion


        
    }
}
